package com.atguigu.tingshu.album.service.impl;

import com.atguigu.tingshu.album.mapper.AlbumAttributeValueMapper;
import com.atguigu.tingshu.album.mapper.AlbumInfoMapper;
import com.atguigu.tingshu.album.mapper.AlbumStatMapper;
import com.atguigu.tingshu.album.service.AlbumInfoService;
import com.atguigu.tingshu.common.constant.KafkaConstant;
import com.atguigu.tingshu.common.constant.RedisConstant;
import com.atguigu.tingshu.common.constant.SystemConstant;
import com.atguigu.tingshu.common.service.KafkaService;
import com.atguigu.tingshu.common.util.AuthContextHolder;
import com.atguigu.tingshu.model.album.AlbumAttributeValue;
import com.atguigu.tingshu.model.album.AlbumInfo;
import com.atguigu.tingshu.model.album.AlbumStat;
import com.atguigu.tingshu.query.album.AlbumInfoQuery;
import com.atguigu.tingshu.vo.album.AlbumAttributeValueVo;
import com.atguigu.tingshu.vo.album.AlbumInfoVo;
import com.atguigu.tingshu.vo.album.AlbumListVo;
import com.atguigu.tingshu.vo.album.AlbumStatVo;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.tencentcloudapi.ame.v20190916.models.Album;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

@Slf4j
@Service
@SuppressWarnings({"unchecked", "rawtypes"})
public class AlbumInfoServiceImpl extends ServiceImpl<AlbumInfoMapper, AlbumInfo> implements AlbumInfoService {

	@Autowired
	private AlbumInfoMapper albumInfoMapper;

	@Autowired
	private AlbumAttributeValueMapper albumAttributeValueMapper;

	@Autowired
	private AlbumStatMapper albumStatMapper;

	@Autowired
	private KafkaService kafkaService;

	@Autowired
	private RedisTemplate redisTemplate;

    @Tag(name = "添加专辑")
	@Transactional
	@Override
	public void saveAlbumInfo(AlbumInfoVo albumInfoVo) {
         //获取用户id
		Long userId = AuthContextHolder.getUserId();
		//保存专辑的基本数据
		AlbumInfo albumInfo = new AlbumInfo();                    //	创建专辑对象
		BeanUtils.copyProperties(albumInfoVo, albumInfo);         //	属性拷贝
		albumInfo.setStatus(SystemConstant.ALBUM_STATUS_PASS);    //	设置专辑审核状态为：通过
		albumInfo.setUserId(userId);

		//  付费的默认前5集免费看
		if(!SystemConstant.ALBUM_PAY_TYPE_FREE.equals(albumInfo.getPayType())) {
			albumInfo.setTracksForFree(5);
		}
		//	保存专辑
		this.save(albumInfo);

		//	保存专辑属性值:
		List<AlbumAttributeValueVo> albumAttributeValueVoLists = albumInfoVo.getAlbumAttributeValueVoList();
		//判断属性集合不为空
		if(!CollectionUtils.isEmpty(albumAttributeValueVoLists)){
			//循环遍历属性集合
			albumAttributeValueVoLists.stream().forEach(albumAttributeValueVo -> {
				AlbumAttributeValue albumAttributeValue = new AlbumAttributeValue();
				BeanUtils.copyProperties(albumAttributeValueVo, albumAttributeValue);
				albumAttributeValue.setAlbumId(albumInfo.getId());
				//	保存数据
				albumAttributeValueMapper.insert(albumAttributeValue);
			});
		}

		log.info("保存专辑信息成功");
		//保存初始化统计数据
		this.saveAlbumStat(albumInfo.getId(), SystemConstant.ALBUM_STAT_PLAY);
		this.saveAlbumStat(albumInfo.getId(), SystemConstant.ALBUM_STAT_SUBSCRIBE);
		this.saveAlbumStat(albumInfo.getId(), SystemConstant.ALBUM_STAT_BROWSE);
		this.saveAlbumStat(albumInfo.getId(), SystemConstant.ALBUM_STAT_COMMENT);

		//判断isOpen字段是否为1
		if("1".equals(albumInfo.getIsOpen())){
			kafkaService.sendMessage(KafkaConstant.QUEUE_ALBUM_UPPER, String.valueOf(albumInfo.getId()));
		}
	}


	private void saveAlbumStat(Long albumId, String statType){
		//AlbumStat 初始化统计数据
		AlbumStat albumStat=new AlbumStat();
		albumStat.setStatType(statType);
		albumStat.setAlbumId(albumId);
		albumStat.setStatNum(0);

		albumStatMapper.insert(albumStat);
		}


	@Tag(name = "分页")
	@Override
	public IPage<AlbumListVo> findUserAlbumPage(AlbumInfoQuery albumInfoQuery, Integer pageNo, Integer pageSize) {

		//获取当前用户Id
		Long userId = AuthContextHolder.getUserId();
		albumInfoQuery.setUserId(userId);

		//创建分页对象
		Page<AlbumListVo> page = new Page<>(pageNo,pageSize);
		IPage<AlbumListVo>result = albumInfoMapper.findUserAlbumPage(page,albumInfoQuery);
		return result;
	}

	@Tag(name = "删除专辑")
	@Transactional
	@Override
	public void removeAlbumInfo(Long albumId) {
		//删除基本数据
		albumInfoMapper.deleteById(albumId);
		//删除属性
		LambdaQueryWrapper<AlbumAttributeValue> lambdaQueryWrapper = new LambdaQueryWrapper<>();
		lambdaQueryWrapper.eq(AlbumAttributeValue::getAttributeId, albumId);
		albumAttributeValueMapper.delete(lambdaQueryWrapper);

		//删除统计数据
		LambdaQueryWrapper<AlbumStat> statLambdaQueryWrapper = new LambdaQueryWrapper<>();
		statLambdaQueryWrapper.eq(AlbumStat::getAlbumId, albumId);
		albumStatMapper.delete(statLambdaQueryWrapper);


		kafkaService.sendMessage(KafkaConstant.QUEUE_ALBUM_LOWER, String.valueOf(albumId));

	}

	@Tag(name = "根据id查询专辑信息")
	@Override
	public AlbumInfo getAlbumInfo(Long albumId) {
		//根据专辑id查询专辑数据
		AlbumInfo albumInfo = albumInfoMapper.selectById(albumId);
		//根据专辑id查询专辑属性数据
		if(albumInfo!= null){
			LambdaQueryWrapper<AlbumAttributeValue>lambdaQueryWrapper = new LambdaQueryWrapper<>();
			lambdaQueryWrapper.eq(AlbumAttributeValue::getAlbumId, albumId);
			List<AlbumAttributeValue> albumAttributeValues = albumAttributeValueMapper.selectList(lambdaQueryWrapper);
			albumInfo.setAlbumAttributeValueVoList(albumAttributeValues);
		}
		return albumInfo;
	}


	@Tag(name = "修改专辑")
	@Transactional
	@Override
	public void updateAlbumInfo(Long albumId, AlbumInfoVo albumInfoVo) {

		//删除Redis中之前的数据
//		redisTemplate.delete(RedisConstant.ALBUM_INFO_PREFIX+albumId);

		//更新专辑的基本数据
		AlbumInfo albumInfo = albumInfoMapper.selectById(albumId);
		BeanUtils.copyProperties(albumInfoVo, albumInfo);
		albumInfoMapper.updateById(albumInfo);
		//更新专辑的基本属性数据
		//根据专辑id删除之前的属性数据
		LambdaQueryWrapper<AlbumAttributeValue>lambdaQueryWrapper = new LambdaQueryWrapper<>();
		lambdaQueryWrapper.eq(AlbumAttributeValue::getAlbumId, albumId);
		albumAttributeValueMapper.delete(lambdaQueryWrapper);
		//保存新的专辑属性数据
		List<AlbumAttributeValueVo> albumAttributeValueVoList = albumInfoVo.getAlbumAttributeValueVoList();
		albumAttributeValueVoList.stream().forEach(albumAttributeValueVo -> {
			AlbumAttributeValue albumAttributeValue = new AlbumAttributeValue();
			albumAttributeValue.setAlbumId(albumId);
			albumAttributeValue.setAttributeId(albumAttributeValueVo.getAttributeId());
			albumAttributeValue.setValueId(albumAttributeValueVo.getValueId());
			albumAttributeValueMapper.insert(albumAttributeValue) ;
		});

		//再次删除数据 使线程休眠
//		try {
//			TimeUnit.MILLISECONDS.sleep(200);
//			redisTemplate.delete(RedisConstant.ALBUM_INFO_PREFIX+albumId);
//		} catch (InterruptedException e) {
//			e.printStackTrace();
//		}

		//判断isOpen是否为1
		if("1".equals(albumInfo.getIsOpen())){
			kafkaService.sendMessage(KafkaConstant.QUEUE_ALBUM_UPPER, String.valueOf(albumId));
		}else{
			kafkaService.sendMessage(KafkaConstant.QUEUE_ALBUM_LOWER, String.valueOf(albumId));
		}
	}


     @Tag(name = "上传音频接口，根据id获取当前用户全部专辑列表")
	 @Override
	public List<AlbumInfo> findUserAllAlbumList(Long userId) {
		LambdaQueryWrapper<AlbumInfo> lambdaQueryWrapper = new LambdaQueryWrapper<>();
		lambdaQueryWrapper.eq(AlbumInfo::getUserId, userId);
		lambdaQueryWrapper.select(AlbumInfo::getUserId,AlbumInfo::getAlbumTitle).orderByDesc(AlbumInfo::getId);
		List<AlbumInfo> albumInfoList = albumInfoMapper.selectList(lambdaQueryWrapper);
		return albumInfoList;
	}

	@Override
	public AlbumStatVo findAlbumStatByAlbumId(Long albumId) {
		AlbumStatVo albumStatVo = albumStatMapper.findAlbumStatByAlbumId(albumId);
		return albumStatVo;
	}

	@Override
	public AlbumStatVo getAlbumStatVoByAlbumId(Long albumId) {
		return albumInfoMapper.selectAlbumStat(albumId);
	}
}
